The present invention relates generally to data processing systems and, more particularly, to utilizing a challenge-response authentication protocol for datagram-based or connectionless remote procedure calls.
A xe2x80x9cremote procedure callxe2x80x9d (RPC) refers to a client program invoking a procedure or function of a remote server program, where the two computer-programs are typically in separate address spaces on a single computer or the two computer programs are on separate computers. After invoking the procedure, the results of the invocation (e.g., success or failure) and any output parameters are usually returned to the client program.
FIG. 1 depicts a block diagram of a conventional system for performing remote RPCs. The conventional RPC system, as depicted in FIG. 1, has a client computer 102 interconnected to a server computer 104 by a network 106. The client computer contains a client program 108, an RPC runtime facility 110, and a transport layer 112. The client program 108 is the originator of an RPC. The RPC runtime 110 receives a message containing a request for the RPC from the client program 108, encrypts the message, and passes the encrypted message to the transport layer 112. The RPC runtime 110 encrypts messages that are sent, as well as decrypts messages that are received. The encryption is performed using an encryption algorithm with an encryption key. By using the encryption algorithm with the encryption key, plain text can be encrypted, and conversely, the encrypted text can be decrypted using the same key and the same algorithm. Sometimes the encryption key is only valid for a single session or conversation between the client computer 102 and the server computer 104. In this situation, the encryption key is referred to as a xe2x80x9csession key.xe2x80x9d
The transport layer 112 receives an encrypted request for an RPC from the RPC runtime 110 and transmits the encrypted request to the transport layer 118 of the server computer 104 by dividing the request into a number of packets and sending the packets across the network 106. This technique is known as packet switching. Although the client computer 102 and the server computer 104 appear to be directly connected by the network 106, in most circumstances, they will not be, and therefore, the packets must be routed between other, intermediate computers (xe2x80x9cnodesxe2x80x9d) within the network. Each node may be used for routing one or more packets between the client computer 102 and the server computer 104. There are two techniques for sending packets across a network: virtual circuit transmission and datagram transmission. In virtual circuit transmission, the routing through the network is fixed. That is, a path (a logical connection, i.e., xe2x80x9ca virtual circuitxe2x80x9d) through the intermediate nodes is predetermined and all of the packets travel over this logical connection. In a datagram transmission, a single path for transmitting all the packets is not predetermined; rather, each packet can be sent on a different path. While virtual circuit transmission provides for predetermined routing decisions, datagram transmission can take advantage of real time fluctuations in network traffic and can lead to increased throughput because routing decisions are made in response to real time conditions in the network as each packet is transferred.
The server computer 104 contains a server program 114, an RPC runtime 116, and a transport layer 118. The server program 114 acts as the recipient of the remote procedure call. In other words, a function of the server program 114 is remotely invoked by the client program 108. The transport layer 118 performs a similar function to the transport layer 112. The RPC runtime facility 116 performs encryption and decryption of messages to provide for secure communications and also performs authentication to prevent unauthorized access to the server computer 104. One type of unauthorized access is known as replay. The term xe2x80x9creplayxe2x80x9d refers to a situation where an intruder listens to and records the conversation of both the client computer 102 and the server computer 104 and then replays the conversation (i.e., the messages) to violate the integrity of the system. In order to prevent replay and other types of unauthorized access during an RPC, the client computer 102 and the server computer 104 communicate using an authentication protocol that verifies the identity of the originator of the RPC (i.e., the client program being run under a particular user""s account). It also verifies that the same packets are not received twice.
When an RPC is performed using a transport layer that communicates using virtual circuit transmission, various authentication protocols can be used because the client is notified when the server terminates the logical connection. That is, in a virtual circuit transmission, the transport layers form a logical connection between the RPC runtime 110 on the client computer 102, through the intermediate nodes in the network 106 and to the RPC runtime 116 on the server computer 104. When this logical connection is broken, the RPC runtime on both ends of the logical connection is notified from its respective transport layer. The notification of failure facilitates the use of an authentication protocol in the following way. During the normal processing of an RPC, if the transport 118 has waited for what it considers to be too long of a time without receiving a communication from the transport 112, the transport 118 may drop the logical connection, upon the occurrence of which the server RPC runtime 116 will be notified and will discard all information relating to the session (xe2x80x9ccontext informationxe2x80x9d), including the session key used to encrypt and decrypt the messages transferred during the session. In a connection-oriented RPC (i.e., an RPC over a virtual circuit connection), the client RPC runtime receives a notification that the logical connection has terminated and the client RPC runtime can then perform reauthentication and obtain another copy of the session key so that the session can resume. However, in the case of datagram transmissions, since there is no logical connection, the client RPC runtime does not receive a notification that the logical connection has terminated and the server RPC runtime has discarded its context information, so the client RPC runtime does not know to perform reauthentication and obtain the session key and thus the session cannot resume. As such, connection-oriented authentication protocols do not work when using datagram transmission.
To perform authentication for datagram-based remote procedure calls, the Kerberos protocol is typically used. FIG. 2 depicts a block diagram of the relevant components of a conventional RPC system 200 using the Kerberos protocol. In the conventional RPC system 200, a client computer 202 is interconnected to a server computer 204 via a network 208 and is also interconnected to an authentication server computer 206 via a network 210. A program on the client computer 202 invokes a function of a program on the server computer 204. The authentication server 206 is responsible for creating session keys that will be used by both the client computer 202 and the server computer 204 to encrypt and decrypt messages. The authentication server 206 sends the session keys to both the client computer 202 and the server computer 204 via its connection to the client computer 202. Obtaining the session key from the authentication server 206 is both inflexible and time consuming, because the authentication server dictates which session key to use, and the client computer is usually connected to the authentication server via a rather slow connection.
Another disadvantage of the Kerberos authentication protocol is the manner in which it prevents replay from occurring. In the Kerberos protocol, replay is prevented by both the client computer 202 and the server computer 204 maintaining synchronized clocks so that when the server computer receives a request for an RPC and decrypts the request, the server computer can determine whether the message is a replay of an earlier message by comparing a time stamp contained in the request to the server computer""s internally synchronized clock. If the message is determined to be a replay, the server computer can conclude that the message originated from an intruder instead of a bona fide client. Although this method for preventing replay is effective, maintaining the synchronicity of the clocks of the client computer and the server computer adds significant overhead to the system and is rather difficult to perform. Based upon the above drawbacks to the Kerberos protocol, it is desirable to improve upon the authentication protocol used in a datagram-based RPC environment.
The disclosed system uses a challenge-response authentication protocol for datagram-based or connectionless remote procedure calls. Using a challenge-response authentication protocol has many advantages over using a conventional Kerberos authentication protocol. For example, in a system using the challenge-response authentication protocol, the client computer generates the session key and thus provides the client computer with the flexibility of choosing a more secure session key if it so desires. Furthermore, since the client generates the session key itself instead of having to receive it via a slow connection to a separate computer, the generation of the session key is less time consuming than in the conventional Kerberos authentication protocol system. Also, in using a challenge-response authentication protocol, replay is prevented without the use of synchronized clocks. Instead, replay prevention is an inherent part of the challenge-response protocol and is therefore performed in an easy and efficient manner with little overhead. Another advantage of using the challenge-response authentication protocol is that many existing network operating systems, such as WINDOWS NT available from Microsoft Corporation of Redmond, Wash., are capable of performing a similar type of protocol using virtual circuit transmission. Thus, providing a challenge-response protocol using datagram transmission can provide the above-described advantages with little modifications to existing network operating systems.
There are two primary components responsible for communicating using the challenge-response protocol: a challenge-response protocol component on the client computer (client C-R component) and a challenge-response protocol component on the server computer (server C-R component). In order to start a session using the challenge-response protocol, the client C-R component first generates a session key. The session key is used by both the client C-R component and the server C-R component for encrypting and decrypting messages. After creating the session key, the client C-R component encrypts a message containing a request for an RPC and sends it to the server C-R component. In response, the server C-R component creates a challenge and has it sent to the client C-R component. The challenge contains a unique identifier generated by the server C-R component. The client C-R component responds to the challenge by sending a challenge response and the session key. The challenge response is the unique identifier contained within the challenge encrypted with the password of the user of the client computer. The session key is also encrypted using this password. Upon receiving the challenge response, the server C-R component uses its copy of the client""s password to create its own version of the challenge response and compares it to the version received from the client C-R component. If the two versions of the challenge response are identical, the identity of the user of the client computer has been verified. If the two versions are not identical, an attempted unauthorized access has been detected. After verification, the server C-R component extracts the session key, decrypts the message, and invokes the requested procedure of the server program. Subsequently, the server C-R component will send and receive encrypted messages from the client C-R component, thereby facilitating an RPC.
In accordance with a first aspect of the present invention, a data processing system is provided comprising a network communicatively connecting a client computer to a server computer. The server computer contains a server computer program, a server challenge-response protocol component, and a server transport component. The server computer program has a function for remote invocation and receives a request to invoke the function. The server challenge-response protocol component receives an encrypted request to invoke the function and sends a unique identifier to the client computer to request a key so that the encrypted request can be decrypted and passed to the server computer program. The server transport component sends and receives a plurality of packets as datagram transmissions over the network to facilitate the invocation of the function. The client computer comprises a client computer program, a client challenge-response protocol component, and a client transport component. The client computer program sends the request to remotely invoke the function of the server computer program. The client challenge-response protocol component receives and encrypts the request to remotely invoke the function, receives the unique identifier from the server challenge-response protocol component, encodes the unique identifier and sends the encoded unique identifier to the server computer with the key. The client transport component sends and receives the plurality of packets as datagram transmissions over the network to facilitate the invocation of the function.
In accordance with a second aspect of the present invention, a method is provided in a data processing system for a client computer program on a client computer having a client protocol component to invoke a function of a server computer program on a server computer having a server protocol component. The client computer and the server computer are interconnected by a network and communicate using datagram-based transmissions over the network. The client protocol component receives a request for invoking a function of the server computer program from the client computer program, encrypts the request using a key, and sends the encrypted request to the server computer via the network using the datagram-based transmissions. The server protocol component receives the encrypted request and sends a challenge containing a unique identifier to the client protocol component. The client protocol component receives the challenge, encodes the challenge and the key, and sends the encoded challenge and the encoded key to the server protocol component. The server protocol component receives the encoded challenge and the encoded key, decodes the encoded challenge and the encoded key, and decrypts the request using the decoded key to process the invocation of the function of the server computer program.